COMMENT ⊗   VALID 00006 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002	header files & the like
C00004 00003	! Standard records 
C00016 00004	! data types
C00018 00005	! operators for expressions
C00023 00006	! predeclared variables & internal system variables
C00026 ENDMK
C⊗;
COMMENT header files & the like;

IFCR ¬DECLARATION(π) THENC 
	ENTRY;
	BEGIN "ALREC"

	REQUIRE "ABBREV.SAI[AL,HE]" SOURCE_FILE;
	REQUIRE "MACROS.SAI[AL,HE]" SOURCE_FILE;
	REQUIRE "RECAUX.HDR[AL,HE]" SOURCE_FILE;
	REQUIRE "REFBTS.DEF[AL,HE]" SOURCE_FILE;

	DEFINE ALRECTERNAL=<INTERNAL>;
	DEFINE ALRECEND=<END>;
	DEFINE ALRECSW = 1;
	DEFINE NOARITH = "TRUE";
	REQUIRE "ARITH.HDR[AL,HE]" SOURCE_FILE;
	
ELSEC
	REQUIRE "ALREC.REL[AL,HE]" LOAD_MODULE;
	DEFINE ALRECEND=<  >;
	DEFINE ALRECTERNAL=<EXTERNAL>;
	DEFINE ALRECSW = 0;
ENDC


! a few constants;

DEFINE INCHES = "2.54";
DEFINE DEGREES = "(π/180.0)";

ALRECTERNAL OWN INTEGER ARRAY PATCH[0:50];
! Standard records ;

DEFINE ALRTYPE(FOO,BAR) "<>" =
	< ASSIGNC BAR = CVPS(FOO)&"TYPE";
	  REDEFINE NHRECS=NHRECS+1;
	  DEFINE BAR = NHRECS>;
DEFINE ALRCLASS(FOO) "<>" = 
	< ALRTYPE(FOO);
	  ALRECTERNAL RECORD_CLASS FOO >;

DEFINE NHRECS=0;
	
	DEFINE	REXPR = <RANY>,
		RVAR = <RPTR(VARIABLE,EXPRN)>,
		RSTMNT = <RPTR(STMNT)>,
		RSSS = <RANY>,
		RBLK = <RPTR(BLOCK)>,
		RTHREAD = <RPTR(THREAD)>;

	! Constants.  **** Now, record classes defined by ARITH ****;
	ALRCLASS (STCONST) (STRING VAL);
	ALRCLASS (CHAR_REC) (INTEGER CHAR);	! Mainly used in gobble;

	ALRTYPE(V3ECT);
	ALRTYPE(ROTN);
	ALRTYPE(TRANS);
	ALRTYPE(SVAL);
	ALRTYPE(TINFO);
	ALRTYPE(FRAME);

	! expressions;

	ALRCLASS (EXPRN) (INTEGER DATATYPE,OP;RCELL ARGS);

	! Variables & their attributes;
				
	ALRCLASS (VNODE) (INTEGER INVMARK; RPTR(VALU$) VAL;
				RPTR(VNODE) NEXT,OLDVAL; RANY VAR,THREAD);
	ALRCLASS (CALC) (INTEGER TYPE; RPTR(CALC) NEXT,NXTCALC,REMCALC;
				RANY US,OTHER,BVAR,THREAD);
		! type: 1 = rigid, 2 = frame 2;
	ALRCLASS (THREAD) (RPTR(VNODE) VALS,DEPRS; RPTR(CALC) CALCS,REMCALCS);
	ALRCLASS (LBLVAR) (STRING NAME;INTEGER DATATYPE;RANY BLK;RANY SEMANTICS);
	ALRCLASS (STMNT)(RSSS SEMANTICS; RPTR(LBLVAR) STLAB);
	ALRCLASS (VARIABLE)(STRING NAME; RANY BLK; INTEGER DATATYPE, OFFSET,
			ATTRIBUTES; RPTR(VNODE) PLNVAL, DEPR; RPTR(CALC) CALCS);
		! Variable attribute bits follow:   ;
		BITDEF(REFARG,'2);  ! This variable is accessed by "reference";
		BITDEF(VALARG,'4);  ! This variable is accessed by "value";
		! BLK is block in which this variable appears;
	ALRCLASS (ARRAYDEF)(STRING NAME; RANY BLK; INTEGER DATATYPE,
				OFFSET, ATTRIBUTES, NUMDIMS;
				REXPR ARRAY BOUNDS; INTEGER ARRAY BDVALS;
				RVAR ARRAY VARS);
	ALRCLASS (PROCDEF) (STRING NAME; RANY BLK; INTEGER DATATYPE, OFFSET,
			ATTRIBUTES, LAB, NUMARGS; RCELL ARGS; RSTMNT BODY);

	! Control structures;

	ALRCLASS (PROG) (RPTR(STMNT) CODE);
	ALRCLASS (BLOCK) (RCELL CODE,VARS,ARAYS,CMONS,EVTS,PROCS;
			      STRING BLID; RBLK PARENT);
	ALRCLASS (COBLOCK) (RCELL CODE);
	ALRCLASS (FORR) (RVAR CONVAR; REXPR INITIAL, STEP, FINAL; RSTMNT BODY);
	ALRCLASS (WHIL) (REXPR COND; RSTMNT BODY);
	ALRCLASS (UNTL) (REXPR COND; RSTMNT BODY);
	ALRCLASS (KASE) (REXPR INDEX; INTEGER RANGE, NSTMNTS;
				 INTEGER ARRAY LABS; RCELL STMNTS);
	ALRCLASS (IFF) (REXPR COND; RSTMNT THN, ELS);
	ALRCLASS (PAUSE) (REXPR VAL);
	ALRCLASS (PROMPT) (REXPR VAL);
	ALRCLASS (PRNT) (REXPR VAL);
	ALRCLASS (ABORT) (REXPR VAL);
	ALRCLASS (RETRN) (REXPR VAL);

	! graph structure manipulators;

	ALRCLASS (ASSIGNMENT) (RVAR VAR; REXPR VAL);
	ALRCLASS (PAS) (RVAR VAR; REXPR VAL);
	ALRCLASS (DEPROACH) (RVAR VAR; REXPR VAL);
	ALRCLASS (PVL)(RCELL VL);
	ALRCLASS (AFFIX) (RVAR FRAME1,FRAME2,BYVAR;REXPR ATEXP;BOOLEAN RIGID);
	ALRCLASS (UNFIX) (RVAR FRAME1,FRAME2);
	ALRCLASS (EVDO)(RVAR VAR; INTEGER OP); ! OP = 0 for signal, =1 for wait;

	ALRCLASS (DEXPR)(RVAR VAR;REXPR EXPN;RPTR(VALU$) VAL;RVAR TMPVAR);
		! This construct is intended as a special kluge to
		  pass destination expressions on to MOVE statements
		  & (perhaps) other PASS3 things that need planning
		  values.  VAR is assumed to be a variable whose
		  value is to be fetched at runtime.  If EXPN is
		  not null, then VAR is probably a temp.  In any event,
		  it is assumed that PASS3 will emit code to compute
		  EXPN & assign it into VAR before using.  VAL
		  is set up by the simulator & contains the planning
		  value of VAR.  TMPVAR is the same as VAR if VAR is
		  a temp.  The reason for this is that the simulator may
		  make several passes over the same statement & I
		  need a way to avoid creating duplicate temps all over
		  the place.
		;

	! motion statements and clauses;

	ALRCLASS (MOVE$) (RVAR WHAT; REXPR DEST; RCELL CLAUSES; REAL SFAC;
				RVAR CF; RPTR(VALU$) CFVAL; RPTR(DEXPR) DEXP);
	ALRCLASS (OPERATE) (RVAR WHAT; REXPR DEST; RCELL CLAUSES; REAL SFAC;
				RVAR CF; RPTR(VALU$) CFVAL; RPTR(DEXPR) DEXP);
		! CF is the controllable frame for this motion statement.
		  DEXP is the DEXPR that gives the ACTUAL destination for
			CF.  
		  **** At present, the program graph is NOT modified
			to generate an assignment statement into DFTEMP.
			It is assumed that the code generator will 
			generate code to evaluate the expression &
			then poke the value away.  WLDMOD will, however,
			call CHANGE to give DFTEMP a correct planning value.;

	DEFINE MAX_VISE_OPENING = "4.6875";

	ALRCLASS (CENTER) (RVAR CF;RCELL CLAUSES);
	ALRCLASS (STOP) (RVAR CF);

	ALRCLASS (CMON) (REXPR CONDITION; RSTMNT CONCLUSION;
		INTEGER OFFSET,FLAGS);
	  BITDEF(DEFER,'1);	! set if deferred cmon;
	  BITDEF(W_ARM,'2);	! set if yellow arm;

	ALRCLASS (CMABLE) (RPTR(CMON,LBLVAR) WHAT;INTEGER FLAG);
		! (FLAG = TRUE) => enable, else disable;

	ALRCLASS (DURATION) (REXPR TIME; INTEGER TIME_RELN);
		! Note:  the time relations are the following:
		0	no relation given
		1	> (that is, a lower bound)
		2	< (that is, an upper bound)
		3	= (that is, an exact bound)
		;
	ALRCLASS (VIA) (REXPR PLACE,VELOC; RPTR(DURATION) TIME;
				RPTR(CMON,EVDO) CODE;RPTR(DEXPR) ACTPLACE);
		! ACTPLACE gives where this VIA must actually go thru. ;

	ALRCLASS (APPROACH) (REXPR THRU; RPTR(CMON,EVDO) CODE;
						RPTR(DEXPR) ACTPLACE);
	ALRCLASS (DEPARTURE) (REXPR THRU; RPTR(CMON,EVDO) CODE;
						RPTR(DEXPR) ACTPLACE);

	ALRCLASS (VELOCITY) (REXPR VELOC);

	ALRCLASS (F_FRAME) (REXPR FRAME; INTEGER C_SYS);

	ALRCLASS (FORCE) (REXPR DIRECT, VAL; INTEGER TYPE,REL; RPTR(F_FRAME) F_F);
		! Type: Torque = False
			Force  = True
		  Rel:	  <  =  SIGLT
			  ≥  =  SIGGE;

	ALRCLASS (STIFF) (REXPR K,G; RPTR(F_FRAME) F_F);

	ALRCLASS (GATHER) (INTEGER BITS);

	! The following bits are used during calls to the force sensing system;

	DEFINE YELARM = '1;	! Yellow arm;
	DEFINE BLUARM = '4;	! Blue arm;

	DEFINE FTABLE = '400;	! Force trans (C) in table coordinates;
	DEFINE FHAND  = '0;	!   "	 "    "   " hand coordinate system;

	DEFINE XFORCE = '0;	! Force along X direction of C;
	DEFINE YFORCE = '1000;	!   "     "   Y	    "     "  ";
	DEFINE ZFORCE = '2000;	!   "     "   Z	    "     "  ";
	DEFINE XMOMENT = '3000;	! Moment about X direction of C;
	DEFINE YMOMENT = '4000;	!   "	   "   Y     "	   "  ";
	DEFINE ZMOMENT = '5000;	!   "	   "   Z     "	   "  ";

	DEFINE FSTOP  = '10000;	! In addition to starting cmon, stop arm;

	DEFINE SIGMAG = '20000;	! Test only magnitude of forces;
	DEFINE SIGGE = '100000;	! Start cmon if force ≥ specified value;
	DEFINE SIGLT = '0;	!   "	  "  "	  "   <	    "	    ";

	ALRCLASS (SETBASE) (INTEGER VAL);  ! These are temporary hacks for JKS;
	ALRCLASS (WRIST) (REXPR K,G);	 ! so he can debug the force wrist;

	ALRCLASS (OPENING) (REXPR VAL);

	ALRCLASS (WOBBLE) (REXPR VAL);

	ALRCLASS (S_FAC) (REXPR VAL);

	ALRCLASS (NNULL) (INTEGER FLAG);

	ALRCLASS (RTMOVE) (INTEGER FLAG); ! use experimental runtime trajectory
						calculator -- for Shahid;
	ALRCLASS (SW_TIME) (REXPR VAL); ! for vise;

	ALRCLASS (CW) (INTEGER FLAG); ! for driver;

	ALRCLASS (ERROR) (REXPR BITS; RSTMNT BODY); ! Error handler for motions;

	ALRCLASS (RETRY) (INTEGER DUMMY); ! for software retries from error handlers;

	ALRTYPE (TO); ! for alternative MOVE syntax;

	! Totally miscellaneous things;
	ALRCLASS (COMMNT) (RANY HESAYS);
	ALRCLASS (NOTE) (RPTR(STCONST) HESAYS);
	ALRCLASS (NOTE1) (RPTR(STCONST) HESAYS);
	ALRCLASS (NOTE2) (RPTR(STCONST) HESAYS);
	ALRTYPE (DEBUG); ! for debugging the gobbler;

! data types;

DEFINE  DEFDTYPE(MNE,XXX) "<>" = <
	REDEFINE NDTYPES=NDTYPES+1;
	ASSIGNC XXX = CVPS(MNE)&"_DTYPE";
	DEFINE XXX = NDTYPES>;

DEFINE NDTYPES=-1;
DEFDTYPE(INVALID);	! 0 is invalid;
DEFDTYPE(SVAL);		! scalar;
DEFDTYPE(V3ECT);	! 3 vector;
DEFDTYPE(ROTN);		! rotation;
DEFDTYPE(TRANS);	! transform matrix;
DEFDTYPE(FRAME);	! frame;

DEFDTYPE(ARAY);		! array;
DEFDTYPE(PROC);		! procedure;
DEFDTYPE(REF);		! call by referemce;
DEFDTYPE(VAL);		! call by value;

DEFDTYPE(EVENT);	! an "event" variable;

! note: Labels get loaded up with the semantics of the thing 
	pointed to.
;

DEFDTYPE(STMLAB);	! statement label;
DEFDTYPE(OMNLAB);	! on-monitor label;
! operators for expressions;

IFCR ALRECSW THENC
DEFINE  DEFOP(MNE,XXX,YYY) "<>" = <
	REDEFINE NOPS=NOPS+1;
	ASSIGNC XXX = CVPS(MNE)&"_OP";
	ASSIGNC YYY = """"&CVPS(MNE)&"""";
	YYY,
	DEFINE XXX = NOPS>;
PRELOAD_WITH 
ELSEC
DEFINE  DEFOP(MNE,XXX) "<>" = <
	REDEFINE NOPS=NOPS+1;
	ASSIGNC XXX = CVPS(MNE)&"_OP";
	DEFINE XXX = NOPS>;
ENDC

DEFINE OPBRK(MXID,MNID,XXX) "<>" = <
	ASSIGNC XXX = "MAX_"&CVPS(MXID)&"_OP";
	DEFINE XXX = NOPS;
	ASSIGNC XXX = "MIN_"&CVPS(MNID)&"_OP";
	DEFINE XXX = NOPS+1>;

!  This list updated 6/30/75 by RF & 7/25/76, 3/2/78 & 5/28/78 by ARG;
DEFINE NOPS=-1;				! Return nothing;
DEFOP(INVALID);
DEFOP(AREF);		! array reference - returns ?;
DEFOP(CALL);		! procedure call - returns ?;
DEFOP(NO);		! no-op;
OPBRK(NO,SVAL);				! Return scalars;
DEFOP(SSBRTN);		! arithmetic functions: sqrt,sin,cos,asin,acos,atan2,log,exp;
	DEFINE  SQRT_OP = "1", SIN_OP = "2", COS_OP = "3", TAN_OP = "4",
		ASIN_OP = "5", ACOS_OP = "6", ATAN2_OP = "7",
		LOG_OP = "8", EXP_OP = "9", TIME_OP = "10";
DEFOP(SCALRD);		! reads in scalar from console;
DEFOP(QUERY);		! reads in boolean from console;
DEFOP(SABS);		! |s| (absolute value);
DEFOP(SADD);		! s+s;
DEFOP(SSUB);		! s-s;
DEFOP(SNEG);		! -s;
DEFOP(SMUL);		! s*s;
DEFOP(SDIV);		! s/s;
DEFOP(SEXP);		! s↑s (not in runtime);
DEFOP(MAX);		! s MAX s;
DEFOP(MIN);		! s MIN s;
DEFOP(INT);		! INT s;
DEFOP(DIV);		! INT(s/s);
DEFOP(MOD);		! s MOD s;
DEFOP(SLT);		! S<S;
DEFOP(SEQ);		! S=S;
DEFOP(SLE);		! S≤S;
DEFOP(SGE);		! S≥S;
DEFOP(SNE);		! S≠S;
DEFOP(SGT);		! S>S;
DEFOP(AND);		! S∧S;
DEFOP(OR);		! S∨S;
DEFOP(XOR);		! S⊗S;
DEFOP(EQV);		! S≡S;
DEFOP(NOT);		! ¬S;
DEFOP(VMAGN);		! |v|;
DEFOP(VDOT);		! v.v;
DEFOP(RMAGN);		! rotation angle of r;
OPBRK(SVAL,V3ECT);			! Return vectors;
DEFOP(VMAKE);		! vector(s,s,s);
DEFOP(SVMUL);		! s*v;
DEFOP(VSDIV);		! v/s;
DEFOP(VADD);		! v+v;
DEFOP(VSUB);		! v-v;
DEFOP(VCROSS);		! v*v;
DEFOP(RVMUL);		! r*v;
DEFOP(TVMUL);		! t*v;
DEFOP(UVECT);		! v/magn(v);
DEFOP(AXIS);		! rotation axis of r;
DEFOP(POS);		! position part of a trans;
OPBRK(V3ECT,ROTN);			! Return rotns;
DEFOP(AXW_ROTN);	! rotation of s radians about v;
DEFOP(ORIENT);		! rotation part of t;
DEFOP(RRMUL);		! r*r;
OPBRK(ROTN,TRANS);			! Return transes;
DEFOP(TMAKE);		! trans(r,v);
DEFOP(CONSTR);		! constr(v,v,v) (origin,x-axis,xy-plane);
DEFOP(FTOF);		! f → f;
DEFOP(TVADD);		! t+v;
DEFOP(TVSUB);		! t-v;
DEFOP(TTMUL);		! t*t;
DEFOP(TINVRT);		! inverse(t);
DEFOP(DEPR);		! deproach(f);
OPBRK(TRANS,FRAME);			! Return frames;
DEFOP(FMAKE);		! frame(R,v);
DEFOP(TFMAKE);		! frame(T);
OPBRK(FRAME,LAST);
DEFOP(LAST);				! Never return;

IFCR ALRECSW THENC
"INVALID";INTERNAL STRING ARRAY OP_MNE[0:LAST_OP+1];	! Used by ALPRIN;
ELSEC
EXTERNAL STRING ARRAY OP_MNE[0:LAST_OP+1];
ENDC

! predeclared variables & internal system variables;

EXTERNAL RCLASS DEFID(STRING NAME; RANY VAL; RPTR(DEFID) NEXT);
EXTERNAL RPTR(DEFID) SYSIDS;

IFCR ALRECSW THENC
    DEFINE PDV(ID,PID,HDT,OFFST,INID) "<>" =
	< 
	  INTERNAL RPTR(VARIABLE) ID;
	  ASSIGNC INID="INI_"&CVPS(ID);
	  PROCEDURE INID;
		BEGIN
		RPTR(DEFID) D;
		ID←NEW_RECORD(VARIABLE);
		VARIABLE:NAME[ID] ← "PID";
		VARIABLE:DATATYPE[ID] ← HDT;
		VARIABLE:OFFSET[ID] ← OFFST;
		D ← NEW_RECORD(DEFID);
		DEFID:NAME[D] ← "PID";
		DEFID:VAL[D] ← ID;
		DEFID:NEXT[D] ← SYSIDS;
		SYSIDS ← D
		END;
	  REQUIRE INID INITIALIZATION>;
ELSEC
    DEFINE PDV(ID,PID,HDT,OFFST) "<>" =
	< EXTERNAL RPTR(VARIABLE) ID >;
ENDC

PDV(YARM,YARM,FRAME_DTYPE,'0);
PDV(YHAND,YHAND,SVAL_DTYPE,'1);
PDV(BARM,BARM,FRAME_DTYPE,'2);
PDV(BHAND,BHAND,SVAL_DTYPE,'3);
PDV(YDEPROACH,YDEPROACH,FRAME_DTYPE,'4);
PDV(BDEPROACH,BDEPROACH,FRAME_DTYPE,'5);
PDV(ARRIVAL,ARRIVAL,EVENT_DTYPE,0);		! Never use the offset;
PDV(VISE,VISE,SVAL_DTYPE,'6);
PDV(FIXED_JAW,FIXED_JAW,FRAME_DTYPE,'7);
PDV(MOVING_JAW,MOVING_JAW,FRAME_DTYPE,'10);
PDV(VISE_OPENING,.VISE_OPENING,TRANS_DTYPE,'11);
PDV(DRIVER,DRIVER,SVAL_DTYPE,0);	! Never use the offset;
PDV(DR_GRASP,DRIVER_GRASP,FRAME_DTYPE,'12);
PDV(DR_TIP,DRIVER_TIP,FRAME_DTYPE,'13);
PDV(DR_TRANS,.DRIVER_TRANS,TRANS_DTYPE,'14);
PDV(DR_TURNS,DRIVER_TURNS,SVAL_DTYPE,'15);
PDV(BA_ERR,BARM_ERROR,SVAL_DTYPE,'16);
PDV(BH_ERR,BHAND_ERROR,SVAL_DTYPE,'17);
PDV(YA_ERR,YARM_ERROR,SVAL_DTYPE,'20);
PDV(YH_ERR,YHAND_ERROR,SVAL_DTYPE,'21);
PDV(VI_ERR,VISE_ERROR,SVAL_DTYPE,'22);
PDV(DR_ERR,DRIVER_ERROR,SVAL_DTYPE,'23);
PDV(SPEED_FACTR,SPEED_FACTR,SVAL_DTYPE,'24);

ALRECEND